/*package com.comm.db.jdbc;

 

import java.sql.*;
import java.util.*;
import java.io.*;

 

 

*//**
 * <p>
 * Title:数据库连接池
 * </p>
 * <p>
 * Copyright: Copyright (c) 2008
 * </p>
 * <p>
 * Company:inte
 * </p>
 * 
 * @author <a href="mailto:www.qianlijob.com">www.qianlijob.com</a> 
 * @version 1.0
 *//*

public class ConnectPool extends Thread {
	 

	 连接池，存放已创建但未使用的连接 

	static int MinCon_number = 1;

	static int MaxCon_number = 50;
	static int wait_time=600000;//线程等待时间

	 已经创建连接池计数 
	private int created = 0;

	private static int step_number = 3;

	  空闲连接等待释放的时间(秒) 
	int idleTime = 1800;

	是否需要停止线程
	boolean stopThread = false;

	各种同步锁对象，据说byte[]对象创建时间最短，占资料最少
	private byte[] createdLock = new byte[0];

	private byte[] usingLock = new byte[0];

	private byte[] poolLock = new byte[0];

	private byte[] returnedPoolLock = new byte[0];

	单实例
	private static ConnectPool instance = new ConnectPool();

	*//**
	 * 私有的构造方法，防止从外部直接实例化
	 *  
	 *//*
	private ConnectPool() {
		 初始化数据库连接参数 
	 
		init();
		 

		 启动服务线程 
		start();
	 
		
		
	}

	*//**
	 *  对连接池中的连接进行管理，每三分钟更新连接。
	 *
	 * 使程序等待给定的毫秒数
	 * wait(5000); // 等 5 秒  60000=1分钟
	 * @param 给定的毫秒数
	 *//*
	private synchronized void manageConnection() {
		try {
			
			//logger.info(" 服务线程.wait( 10 0000). 10分钟:");//+DateUtil.instance.timePrinting());
			 
			//wait(5000);//
			 sleep(wait_time);//等待10分钟更新连接。
			//logger.info(" 服务线程.wait( 10 0000). 10分钟后:");//DateUtil.instance.timePrinting());
		} catch (InterruptedException e) {
			//    Auto-generated catch block
			e.printStackTrace();
		}
		Connection connection = null;
		for (int i = 0; i < step_number; i++) {
			if (getVector().size() > 0) {
				//取到最早的连接
				connection = getConnectFormPool();//
				 
				removeVector(connection);
				try {
					if (connection != null)
						connection.close();
				} catch (SQLException e) {

					e.printStackTrace();
				}

			}
			connection = JDBC.createConnection();
			if (connection != null){
			 
				setConnectToPool( connection );}
		}

	}
	public synchronized  static Connection getConnectFormPool(){//取到第一个连接
		return getVector().get(0);
		
	}
	 *//**
	  * 向线程池中加入一个连接。
	  * @param _conn
	  *//*
	public synchronized  static void setConnectToPool( Connection _conn){
	
   		getVector().add(_conn);
	}
	public synchronized static Vector<Connection> getVector(){
		 
		 if( SessionImpls.connList==null){
			try {
				sleep(1000);
				return SessionImpls.connList;
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			}else {
				 return SessionImpls.connList;
			}
		   return SessionImpls.connList;
	}
	*//**
	 * 从线程池中移走一个连接
	 * @param _conn
	 *//*
	public synchronized static void removeVector(Connection _conn){
		  
		  getVector().remove(_conn);
	}
	public void run()  
	{   while(true){
			manageConnection();
	  }
	}
	*//**
	 * 从外部取得本类实例的唯一方法
	 * 
	 * @return ConnectPool
	 *//*
    public static ConnectPool getInstance() {
		return instance;
	} 

	private void init() {
		for (int i = 0; i < MinCon_number; i++) {
			Connection conn_init = JDBC.createConnection();
			setConnectToPool(conn_init);
		}

	}

}
*/